package 牛客网在线编程题库;

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;

/**
 * 题目描述
 * 设计LRU缓存结构，该结构在构造时确定大小，假设大小为K，并有如下两个功能
 * set(key, value)：将记录(key, value)插入该结构
 * get(key)：返回key对应的value值
 * [要求]
 * set和get方法的时间复杂度为O(1)
 * 某个key的set或get操作一旦发生，认为这个key的记录成了最常使用的。
 * 当缓存的大小超过K时，移除最不经常使用的记录，即set或get最久远的。
 * 若opt=1，接下来两个整数x, y，表示set(x, y)
 * 若opt=2，接下来一个整数x，表示get(x)，若x未出现过或已被移除，则返回-1
 * 对于每个操作2，输出一个答案
 * 示例1
 * 输入
 * 复制
 * [[1,1,1],[1,2,2],[1,3,2],[2,1],[1,4,4],[2,2]],3
 * 返回值
 * 复制
 * [1,-1]
 * 说明
 * 第一次操作后：最常使用的记录为("1", 1)
 * 第二次操作后：最常使用的记录为("2", 2)，("1", 1)变为最不常用的
 * 第三次操作后：最常使用的记录为("3", 2)，("1", 1)还是最不常用的
 * 第四次操作后：最常用的记录为("1", 1)，("2", 2)变为最不常用的
 * 第五次操作后：大小超过了3，所以移除此时最不常使用的记录("2", 2)，加入记录("4", 4)，并且为最常使用的记录，然后("3", 2)变为最不常使用的记录
 */

public class _设计LRU缓存结构 {
    /**
     * lru design
     * @param operators int整型二维数组 the ops
     * @param k int整型 the k
     * @return int整型一维数组
     */
    public int[] LRU (int[][] operators, int k) {
        // write code here
        // 定义哈希表，使用LinkedHashMap是因为它的key是按照顺序存放的，这样删除第一个放进去的值很方便
        HashMap<Integer, Integer> map = new LinkedHashMap<>();
        // 返回记录表
        LinkedList<Integer> list = new LinkedList<>();
        // 循环遍历出每一次操作
        for (int[] operator : operators) {
            // 取出操作种类
            int curOperator = operator[0];
            // 取出键
            int key = operator[1];
            // 将操作按种类分类
            switch (curOperator) {
                // 插入操作
                case 1:
                    // 获取值
                    int value = operator[2];
                    // 若此时哈希表的长度未超过K
                    if (map.size() < k) {
                        // 直接插入哈希表
                        map.put(key, value);
                    }else {
                        // 此时哈希表的长度超过了K
                        // 生成哈希表迭代器
                        Iterator it = map.keySet().iterator();
                        // 删除第一个放进去的值
                        map.remove(it.next());
                        // 将当前值放入哈希表
                        map.put(key, value);
                    }
                    break;
                // 获取操作
                case 2:
                    // 查询哈希表中是否有该键
                    if (map.containsKey(key)) {
                        // 如果有该键，取出对应的值
                        int val = map.get(key);
                        // 存入返回记录表
                        list.add(val);
                        // 从哈希表中移除该键
                        map.remove(key);
                        // 重复插入哈希表，将其变为最常使用的元素
                        map.put(key, val);
                    }else {
                        // 如果没有该键，则存入-1
                        list.add(-1);
                    }
                    break;
                default:
                    break;
            }
        }
        // 返回查询到的数组元素
        int[] res = new int[list.size()];
        int i = 0;
        for (int val : list) {
            res[i++] = val;
        }
        return res;
    }

    public static void set(int key, int value) {

    }

    public static int get(int key) {
        // 代码都在第一个函数里
        return -1;
    }
}
